Agent Workflow Prompt: Autonomous Personality-Driven Twitter Agent

Project Goal: Transform the moondevonyt/moon-dev-ai-agents repository into an autonomous agent that emulates a specific user's writing style and Twitter personality, generating and posting tweets continuously throughout the day.

Workflow Structure: This workflow follows a phased approach. Each task is designed to be executed sequentially by an AI agent (e.g., @copilot). The output of each task serves as the input for the next, ensuring a cohesive final product.

Phase 1: Foundation & Personality Customization

Objective: To adapt the existing tweet_agent.py to understand and replicate a specific user's unique writing style.

Task 1.1: Analyze Writing Style & Create a Personality Manifest

• Agent Persona: @copilot/agents/personality-analyst - An expert in linguistic analysis and creative writing, skilled at identifying and codifying an individual's tone, style, and personality from text.
• Task: Analyze a provided body of text (e.g., user's blog posts, existing tweets, articles) to define their unique writing personality.
• Input: A collection of text written by the user mostlyfutures.
• Steps:
  1. Read and analyze the provided text samples.
  2. Identify key characteristics of the writing style:
     • Tone: (e.g., humorous, serious, cynical, optimistic, technical).
     • Vocabulary: (e.g., use of slang, jargon, formal language, specific keywords).
     • Sentence Structure: (e.g., short and punchy, long and descriptive, simple, complex).
     • Formatting: (e.g., use of emojis, hashtags, capitalization, line breaks, punctuation style).
     • Common Themes: (e.g., technology, finance, AI, futurism).
• Goal: To produce a detailed "Personality Manifest".
• Format Output: A Markdown section formatted exactly like the Manifest in tweet_agent.py, but tailored to the user.
  • Example Output:

    Manifest:
    - Witty and slightly cynical tone.
    - Uses tech jargon but explains it simply.
    - Prefers short, declarative sentences.
    - Frequently uses the '🤔' and '🚀' emojis.
    - Avoids capitalization for a more casual feel.
    - Often talks about AI, decentralization, and market trends.
    - Hashtags should be lowercase and appended at the very end (e.g., #aifuture).

Task 1.2: Implement the Personality Manifest

• Agent Persona: @copilot/agents/python-expert - A developer specializing in modifying and refactoring existing Python code.
• Task: Hardcode the new, personalized Manifest into the tweet_agent.py script.
• Input: The tweet_agent.py file and the Personality Manifest from Task 1.1.
• Steps:
  1. Open src/agents/tweet_agent.py.
  2. Locate the TWEET_PROMPT multi-line string variable.
  3. Replace the entire existing Manifest: block with the new Personality Manifest created in the previous task.
• Goal: To permanently alter the agent's core personality prompt.
• Format Output: The modified src/agents/tweet_agent.py file.

Phase 2: Architectural Transformation for Continuous Operation

Objective: To refactor the agent from a one-off script into a service that runs continuously and posts automatically.

Task 2.1: Design Continuous Scheduling & Automated Posting Architecture

• Agent Persona: @copilot/agents/system-architect - A senior engineer who designs robust, scalable, and fault-tolerant systems.
• Task: Design the architectural changes needed for the TweetAgent to run on a schedule and post to Twitter automatically.
• Input: The entire moondevonyt/moon-dev-ai-agents repository structure.
• Steps:
  1. Scheduling: Propose a scheduling mechanism. Draw inspiration from sentiment_agent.py's CHECK_INTERVAL_MINUTES. The main execution block should contain a while True: loop with a time.sleep() call to pause between runs. The interval should be configurable.
  2. Auto-Posting: Propose integrating a Twitter API client. The recommended library is tweepy. The design should include a new function, e.g., post_tweet(text), within the TweetAgent class.
  3. Configuration: Propose a centralized configuration file (config.py or similar) to store TWITTER_API_KEY, TWITTER_API_SECRET, ACCESS_TOKEN, ACCESS_TOKEN_SECRET, and TWEET_INTERVAL_SECONDS. This avoids hardcoding secrets.
  4. Error Handling: Plan for potential errors like API rate limits, network failures, or invalid credentials. The agent should log errors and continue running.
• Goal: A clear architectural plan for the transformation.
• Format Output: A Markdown document outlining the plan with code snippets for the proposed main loop, new functions, and configuration structure.

**...